home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / uw201.zip / UW_HELP3.HLP < prev    next >
Text File  |  1991-10-07  |  20KB  |  632 lines
  1. `co(4,7);──────────────────────── /// The Keyboard/Mouse ────────────────────────────`co();
  2.  
  3. ┌──────────────────────────────────────────────────────────────────────────┐    
  4. │        `keyword(init_mouse,/// init_mouse);              `keyword(end_mouse ,/// end_mouse);            `keyword(m_reset     ,/// m_reset);        │
  5. │        `keyword(set_idle_func,/// set_idle_func);           `keyword(wait_event,/// wait_event);            `keyword(event_pending,/// event_pending);       │
  6. │        `keyword(wait_ticks,/// wait_ticks);              `keyword(check_key ,/// check_key);            `keyword(get_key     ,/// get_key);        │
  7. │        `keyword(m_hide,/// m_hide);                  `keyword(m_show    ,/// m_show);            `keyword(m_pos    ,/// m_pos);           │
  8. │        `keyword(m_moveto,/// m_moveto);                `keyword(m_pressed ,/// m_pressed);            `keyword(m_released  ,/// m_released);        │
  9. │        `keyword(m_colrange,/// m_colrange);              `keyword(m_rowrange,/// m_rowrange);            `keyword(m_motion     ,/// m_motion);       │
  10. │        `keyword(m_lpen_on,/// m_lpen_on);               `keyword(m_lpen_off,/// m_lpen_off);            `keyword(m_ratio      ,/// m_ratio);       │
  11. └──────────────────────────────────────────────────────────────────────────┘
  12.  
  13.  
  14.         The UltraWin library interfaces to the user through either the
  15.     keyboard, mouse, or both!  The keyboard routines support all possible
  16.     key presses which include left and right Shift, Alt, and Ctrl key
  17.     combinations.
  18.         The mouse routines allow complete control of a two or three button
  19.     mouse, and is Microsoft driver compatible.    The event routines handle
  20.     detecting both mouse and keyboard presses for you, so making your
  21.     programs support a mouse is a snap!
  22.         In addition, UltraWin allows you to define your own background
  23.     function, which is called any place in the library that waits for
  24.     user input.  This allows you to write your own processing routines to
  25.     be performed in the background, then call one function to notify the
  26.     library of your routine, then just forget all about it!  Refer to
  27.     the set_idle_func and wait_event functions for details.
  28.  
  29. `co(10,1);/// init_mouse`co();   `keyword(source,[UW_EVENT.C]~init_mouse);
  30.     Call this function just after init_video or force_video if you wish
  31.     to use the mouse in your program.  If the mouse is connected and a
  32.     driver is installed, then the global variable Mouse_exists is
  33.     set to TRUE (1). In addition the mouse cursor column and row ranges
  34.     are set to cover the entire text screen.    After calling this function
  35.     you may show the mouse on the screen using the function m_show.
  36.  
  37. Prototype:
  38.     void init_mouse();
  39.  
  40. Parameters:
  41.     None.
  42.  
  43. Usage:
  44.     init_mouse();
  45.  
  46. `co(10,1);/// end_mouse`co();   `keyword(source,[UW_EVENT.C]~end_mouse);
  47.     If the mouse was found to be present in init_mouse, this function
  48.     turns the mouse back off.  This keeps the mouse from being active at
  49.     the DOS prompt.  Call this prior to exiting your program if your
  50.     program called init_mouse or the lower level m_reset function.
  51.  
  52. Prototype:
  53.     void end_mouse();
  54.  
  55. Parameters:
  56.     None.
  57.  
  58. Usage:
  59.     end_mouse();
  60.  
  61. `co(10,1);/// m_reset`co();   `keyword(source,[UW_EVENT.C]~m_reset);
  62.     This is the lower level function called by both init_mouse and
  63.     end_mouse.    It is used both to determine if the mouse exists, and
  64.     also to reset the mouse prior to program exit.
  65.     
  66. Prototype:
  67.     void m_reset(M_RESET *m)
  68.  
  69. Parameters:
  70. `co(11,1);    M_RESET *m`co();
  71.         A variable of type M_RESET.  Refer to the structures/globals
  72.         topic for information on the members of this structure.
  73.  
  74. Usage:
  75.     M_RESET m;
  76.     ...
  77.     m_reset(&m);
  78.  
  79. `co(10,1);/// set_idle_func`co();   `keyword(source,[UW_EVENT.C]~set_idle_func);
  80.     This function allows you to define your own background process.
  81.     Simply write your own C function, keeping in mind that to remain
  82.     responsive to the keyboard you should keep your code tight and
  83.     fast.  Then call set_idle_func with the pointer to your function.
  84.     
  85. Prototype:
  86.     void set_idle_func( int (*func_ptr)() );
  87.  
  88. Parameters:
  89. `co(11,1);    int (*func_ptr)()`co();
  90.         A pointer to the function you wish to install as the idle function.
  91.         
  92. Usage:
  93.     process()
  94.     {
  95.         ...
  96.     }
  97.     ...
  98.     set_idle_func( process );
  99.  
  100. `co(10,1);/// wait_event`co();   `keyword(source,[UW_EVENT.C]~wait_event);
  101.     This function simply waits until either a key is pressed, or a mouse
  102.     button is clicked.    The global variable Event will contain the
  103.     information about the event.    If it is a keyboard event, the key or
  104.     combination of keys pressed is saved.  If a mouse event, then the
  105.     button that was pressed, how many times it was pressed, and the x
  106.     and y coordinate at which the press occurred is saved.
  107.  
  108.     While UltraWin waits for user input, it is free to perform background
  109.     processing.    If a user defined function has been installed with
  110.     set_idle_func, that function will be called during idle time.
  111.     
  112. Prototype:
  113.     void wait_event();
  114.  
  115. Parameters:
  116.     None.
  117.  
  118. Usage:
  119.     wait_event();
  120.  
  121. `co(10,1);/// event_pending`co();   `keyword(source,[UW_EVENT.C]~event_pending);
  122.     This function will check for an event, and will return TRUE (1) if
  123.     an event has occurred or FALSE (0) if no event has occurred.    If
  124.     an event has occurred, then the information about the event, which
  125.     includes the event type (keyboard or mouse), the key and modifier,
  126.     or the mouse location and button status is returned in the global
  127.     Event variable.  Refer to the Event Structures topic for information
  128.     about the EVENT structure and member names for extracting this
  129.     information.
  130.  
  131. Prototype:
  132.     int event_pending();
  133.  
  134. Parameters:
  135.     None.
  136.  
  137. Usage:
  138.     int status;
  139.     ...
  140.     status = event_pending();
  141.  
  142. `co(10,1);/// wait_ticks`co();   `keyword(source,[UW_EVENT.C]~wait_event);
  143.     This function simply waits for a given number of system ticks.    There
  144.     are 18.2 system ticks per second.  If you have defined a background
  145.     process with the set_idle_func function, it will call your process
  146.     function while it waits for the given ticks to pass.  UltraWin 2.0 has
  147.     enhanced timer support.  See `keyword(Timer Support,[uw_help4.hlp]/// Timer Support); for further details.
  148.     
  149. Prototype:
  150.     void wait_ticks( int ticks );
  151.  
  152. Parameters:
  153. `co(11,1);    int ticks`co();
  154.         The number of system ticks to wait.
  155.  
  156. Usage:
  157.     wait_ticks( 9 );
  158.  
  159. `co(10,1);/// check_key`co();   `keyword(source,[UW_EVENT.C]~check_key);
  160.     This function will check to see if a key has been pressed, and will
  161.     return the key without pulling it out of the keyboard buffer.  The
  162.     key value will be returned (see uw_keys.h for key defines).  If no
  163.     key has been pressed, then check_key will return FALSE (0).
  164.  
  165. Prototype:
  166.     int check_key();
  167.  
  168. Parameters:
  169.     None.
  170.  
  171. Usage:
  172.     int key;
  173.     ...
  174.     key = check_key();
  175.  
  176. `co(10,1);/// get_key`co();   `keyword(source,[UW_EVENT.C]~get_key);
  177.     This function will wait until a key has been pressed, and return the
  178.     key value (see uw_keys.h for key defines).
  179.  
  180. Prototype:
  181.     int get_key();
  182.  
  183. Parameters:
  184.     None.
  185.  
  186. Usage:
  187.     int key;
  188.     ...
  189.     key = get_key();
  190.  
  191. `co(10,1);/// m_hide`co();   `keyword(source,[UW_EVENT.C]~m_hide);
  192.     Hides the mouse cursor.  Call this function to remove the mouse
  193.     cursor temporarily from the screen when you are doing window output.
  194.     Call the m_show function after your window output to put the cursor
  195.     back on the screen.
  196.  
  197.     NOTE: Even though the mouse is not shown on the screen, the cursor
  198.     will still track with the mouse, and mouse buttons are still active.
  199.  
  200. Prototype:
  201.     void m_hide();
  202.  
  203. Parameters:
  204.     None.
  205.  
  206. Usage:
  207.     m_hide();
  208.  
  209. `co(10,1);/// m_show`co();   `keyword(source,[UW_EVENT.C]~m_show);
  210.     Show the mouse cursor.    This is used to undo the affect of m_hide.
  211.  
  212. Prototype:
  213.     void m_show();
  214.  
  215. Parameters:
  216.     None.
  217.  
  218. Usage:
  219.     m_show();
  220.  
  221. `co(10,1);/// m_pos`co();   `keyword(source,[UW_EVENT.C]~m_pos);
  222.     Get the current location of the mouse, as well as the status of
  223.     the buttons.
  224.  
  225. Prototype:
  226.     void m_pos( M_LOC *m )
  227.  
  228. Parameters:
  229. `co(11,1);    M_LOC *m`co();
  230.         A pointer to a variable of type M_LOC that contains the position
  231.         and button status information.    Refer to the structures/globals
  232.         topic above for information about the M_LOC structure.
  233.  
  234. Usage:
  235.     M_LOC m;
  236.     ...
  237.     m_pos( &m );
  238.  
  239. `co(10,1);/// m_moveto`co();   `keyword(source,[UW_EVENT.C]~m_moveto);
  240.     Moves the mouse to the position specified by column and row.
  241.  
  242. Prototype:
  243.     void m_moveto( int col, int row );
  244.  
  245. Parameters:
  246. `co(11,1);    int col, row`co();
  247.         The column and row at which the mouse cursor is to be placed.
  248.  
  249. Usage:
  250.     m_moveto( 10, 25 );
  251.  
  252. `co(10,1);/// m_pressed`co();   `keyword(source,[UW_EVENT.C]~m_pressed);
  253.     Checks to see if the button passed has been pressed since the last
  254.     call to this function, and return the button count (number of
  255.     clicks) and the location where the click occurred. A press has
  256.     occurred when the count M_LOC member is greater than 0.
  257.  
  258. Prototype:
  259.     void m_pressed( int button, M_LOC *m );
  260.  
  261. Parameters:
  262. `co(11,1);    int button`co();
  263.         The button to test for being pressed.  This can be one of the
  264.         defines (in uw.h) LB, MB, or RB.
  265. `co(11,1);    M_LOC *m`co();
  266.         A pointer to a variable of type M_LOC that the function will use
  267.         to place the position and button status information.
  268.  
  269. Usage:
  270.     M_LOC m;
  271.     ...
  272.     m_pressed( LB, &m );
  273.  
  274. `co(10,1);/// m_released`co();   `keyword(source,[UW_EVENT.C]~m_released);
  275.     This performs the same function as m_pressed, but is used to test when
  276.     the mouse button is released.
  277.  
  278. Prototype:
  279.     void m_released( int button, M_LOC *m );
  280.  
  281. Parameters:
  282. `co(11,1);    int button`co();
  283.         The button to test for being released.    This can be one of the
  284.         defines (in uw.h) LB, MB, or RB.
  285. `co(11,1);    M_LOC *m`co();
  286.         A pointer to a variable of type M_LOC that the function will use
  287.         to place the position and button status information.
  288.  
  289. Usage:
  290.     M_LOC m;
  291.     ...
  292.     m_released( LB, &m );
  293.  
  294. `co(10,1);/// m_colrange`co();   `keyword(source,[UW_EVENT.C]~m_colrange);
  295.     Allows the user to set the range of columns that the mouse will be
  296.     allowed to move within.  Typically this will be from 0 to V_cols-1,
  297.     but you may set it to a range less than this if you wish to keep
  298.     the mouse inside a subrange of the screen.
  299.  
  300. Prototype:
  301.     void m_colrange( int col_min, int col_max );
  302.  
  303. Parameters:
  304. `co(11,1);    int col_min, col_max`co();
  305.         The column mininum and maximum values.
  306.  
  307. Usage:
  308.     m_colrange( 0, V_cols );
  309.  
  310. `co(10,1);/// m_rowrange`co();   `keyword(source,[UW_EVENT.C]~m_rowrange);
  311.     The complement function to m_colrange.    Typically this will be
  312.     from 0 to V_rows-1, but like m_colrange you may set it to a range
  313.     less than this if you wish to keep the mouse inside a subrange
  314.     of the screen.
  315.  
  316. Prototype:
  317.     void m_rowrange( int row_min, int row_max );
  318.  
  319. Parameters:
  320. `co(11,1);    int row_min, row_max`co();
  321.         The row mininum and maximum values.
  322.  
  323. Usage:
  324.     m_rowrange( 0, V_rows );
  325.  
  326. `co(10,1);/// m_motion`co();   `keyword(source,[UW_EVENT.C]~m_motion);
  327.     Reports the net motion of cursor since last call to this function.
  328.     A pointer to a variable of type M_MOVE is used to pass back the
  329.     information.
  330.  
  331. Prototype:
  332.     void m_motion( M_MOVE *m );
  333.  
  334. Parameters:
  335. `co(11,1);    M_MOVE *m`co();
  336.         A pointer to a variable of type M_MOVE.  See structures/globals
  337.         for information on the M_MOVE members.
  338.  
  339. Usage:
  340.     M_MOVE mv;
  341.     ...
  342.     m_motion( &mv );
  343.  
  344. `co(10,1);/// m_lpen_on`co();   `keyword(source,[UW_EVENT.C]~m_lpen_on);
  345.     Turns on light pen emulation.    This is the default.
  346.  
  347. Prototype:
  348.     void m_lpen_on();
  349.  
  350. Parameters:
  351.     None.
  352.  
  353. Usage:
  354.     m_lpen_on();
  355.  
  356. `co(10,1);/// m_lpen_off`co();   `keyword(source,[UW_EVENT.C]~m_lpen_off);
  357.     Turns off light pen emulation.
  358.  
  359. Prototype:
  360.     void m_lpen_off();
  361.  
  362. Parameters:
  363.     None.
  364.  
  365. Uge:
  366.     m_lpen_off();
  367.  
  368. `co(10,1);/// m_ratio`co();   `keyword(source,[UW_EVENT.C]~m_ratio);
  369.     Sets mouse to pixel ratio.  The default values are 16 for horizontal
  370.     and 8 for vertical.
  371.  
  372. Prototype:
  373.     void m_ratio( int horiz, int vert );
  374.  
  375. Parameters:
  376. `co(11,1);    int horiz, vert`co();
  377.         The values for the new horizontal and vertical ratios.
  378.  
  379. Usage:
  380.     m_ratio( 12, 8 );
  381.  
  382. `co(4,7);──────────────────────── /// The Window Manager ────────────────────────────`co();
  383.  
  384. ┌──────────────────────────────────────────────────────────────────────────┐    
  385. │      `keyword(add_window,/// add_window);              `keyword(remove_window,/// remove_window);         `keyword(make_top_window,/// make_top_window);       │
  386. │      `keyword(cr_inwindow,/// cr_inwindow);             `keyword(move_wn_left,/// move_wn_left);          `keyword(move_wn_right,/// move_wn_right);         │
  387. │      `keyword(move_wn_up,/// move_wn_up);              `keyword(move_wn_down,/// move_wn_down);          `keyword(reset_all_masks,/// reset_all_masks);       │
  388. │      `keyword(refresh_desktop,/// refresh_desktop);         `keyword(refresh_column,/// refresh_column);        `keyword(refresh_row,/// refresh_row);           │
  389. │      `keyword(refresh_rect,/// refresh_rect);                                                        │
  390. └──────────────────────────────────────────────────────────────────────────┘
  391.  
  392.         The window manager is a set of routines that make having multiple
  393.     windows on the screen at once a snap!  By using the window manager,
  394.     you bypass having to keep track of window masking and refreshing,
  395.     as the manager takes care of all the nitty gritty details of multiple
  396.     overlapping windows!    To use the manager, first create a window with
  397.     wn_create that is the size of the screen, and call add_window with
  398.     that window.    This is your background, or desktop window.  Then you
  399.     can add any number (limited only by the amount of memory you have
  400.     in your computer) of windows of any size, regardless of whether
  401.   they overlap each other, and output text to that window using any
  402.     of the window I/O routines.
  403.  
  404. `co(10,1);/// add_window`co();   `keyword(source,[UW_ENTRY.C]~add_window);
  405.     This function takes the window created with wn_create by pointer
  406.     and adds it to the window manager's linked list. The window is
  407.     placed on the screen, and if it overlaps any other window, then
  408.     their masks are set to prevent output to the area that overlaps.
  409.     The window is then drawn on the video screen.
  410.  
  411. Prototype:
  412.     WINDOW *add_window( WINDOW *wnp )
  413.  
  414. Parameters:
  415. `co(11,1);    WINDOW *wnp;`co();
  416.         A pointer to the window created with wn_create.
  417.  
  418. Usage:
  419.     WINDOW wn;
  420.     ...
  421.     add_window( &wn );
  422.  
  423. `co(10,1);/// remove_window`co();   `keyword(source,[UW_WIN.C]~remove_window);
  424.     Takes the window by pointer, and removes it from the linked list.
  425.     Reset any window's masks that were overlapped by the removed window,
  426.     and redraw any portion of any window that was covered by the removed
  427.     window.  Please note that this function calls wn_destroy, so it is
  428.     not necessary to destroy the window once it has been removed from the
  429.     linked list!
  430.  
  431. Prototype:
  432.     int remove_window( WINDOW *wnp );
  433.  
  434. Parameters:
  435. `co(11,1);    WINDOW *wnp;`co();
  436.         A pointer to the window to remove.
  437.  
  438. Usage:
  439.     WINDOW wn;
  440.     ...
  441.     remove_window( &wn );
  442.  
  443. `co(10,1);/// make_top_window`co();   `keyword(source,[UW_WIN.C]~make_top_window);
  444.     This function takes a pointer to the window, and if that window is
  445.     not the top window, it makes it the top window.  All adjustments
  446.     in the masks for all windows are made, and the window is drawn to
  447.     the screen.
  448.  
  449. Prototype:
  450.     int make_top_window( WINDOW *wnp );
  451.  
  452. Parameters:
  453. `co(11,1);    WINDOW *wnp;`co();
  454.         A pointer to the window to bring to the top.
  455.  
  456. Usage:
  457.     WINDOW *wnp;
  458.     ...
  459.     make_top_window(wnp);
  460.  
  461. `co(10,1);/// cr_inwindow`co();   `keyword(source,[UW_WIN.C]~cr_inwindow);
  462.     This function takes a location on the screen, and returns the
  463.     topmost window that contains that location.  If there is no window
  464.     under the location, then a NULL is returned.
  465.  
  466. Prototype:
  467.     WINDOW *cr_inwindow( int col, int row )
  468.  
  469. Parameters:
  470. `co(11,1);    int col, row`co();
  471.         The col,row coordinate (x,y) to check.
  472.  
  473. Usage:
  474.     WINDOW *wnp;
  475.     ...
  476.     wnp = cr_inwindow( 20, 37 );
  477.  
  478. `co(10,1);/// move_wn_left`co();   `keyword(source,[UW_WIN.C]~move_wn_left);
  479.     Takes a window in the manager's linked list, and moves it smoothly to
  480.     the left a given number of columns.
  481.  
  482. Prototype:
  483.     void move_wn_left( int cols, WINDOW *wnp );
  484.  
  485. Parameters:
  486. `co(11,1);    int cols`co();
  487.         The number of columns to move left.
  488. `co(11,1);    WINDOW *wnp;`co();
  489.         A pointer to the window to move.
  490.  
  491. Usage:
  492.     WINDOW *wnp;
  493.     ...
  494.     move_wn_left( 3, wnp );
  495.  
  496. `co(10,1);/// move_wn_right`co();   `keyword(source,[UW_WIN.C]~move_wn_right);
  497.     Takes a window in the manager's linked list, and moves it smoothly to
  498.     the right a given number of columns.
  499.  
  500. Prototype:
  501.     void move_wn_right( int cols, WINDOW *wnp );
  502.  
  503. Parameters:
  504. `co(11,1);    int cols`co();
  505.         The number of columns to move right.
  506. `co(11,1);    WINDOW *wnp;`co();
  507.         A pointer to the window to move.
  508.  
  509. Usage:
  510.     WINDOW *wnp;
  511.     ...
  512.     move_wn_right( 2, wnp );
  513.  
  514. `co(10,1);/// move_wn_up`co();   `keyword(source,[UW_WIN.C]~move_wn_up);
  515.     Takes a window in the manager's linked list, and moves it smoothly up
  516.     a given number of rows.
  517.  
  518. Prototype:
  519.     void move_wn_up( int rows, WINDOW *wnp );
  520.  
  521. Parameters:
  522. `co(11,1);    int rows`co();
  523.         The number of rows to move up.
  524. `co(11,1);    WINDOW *wnp;`co();
  525.         A pointer to the window to move.
  526.  
  527. Usage:
  528.     WINDOW *wnp;
  529.     ...
  530.     move_wn_up( 1, wnp );
  531.  
  532. `co(10,1);/// move_wn_down`co();   `keyword(source,[UW_WIN.C]~move_wn_down);
  533.     Takes a window in the manager's linked list, and moves it smoothly down
  534.     a given number of rows.
  535.  
  536. Prototype:
  537.     void move_wn_down( int rows, WINDOW *wnp );
  538.  
  539. Parameters:
  540. `co(11,1);    WINDOW *wnp;`co();
  541.         A pointer to the window to move.
  542. `co(11,1);    int rows`co();
  543.         The number of rows to move down.
  544.  
  545. Usage:
  546.     WINDOW *wnp;
  547.     ...
  548.     move_wn_down( 1, wnp );
  549.  
  550. `co(10,1);/// reset_all_masks`co();   `keyword(source,[UW_WIN.C]~reset_all_masks);
  551.     Walks through all the windows in the manager's linked list, and
  552.     resets their output masks so that only the areas of the windows
  553.     visible get written upon window output.  Calling this function is
  554.     not necessary unless you adjust a window's mask yourself, and want
  555.     to set all window masks back to their default state.
  556.  
  557. Prototype:
  558.     void reset_all_masks();
  559.  
  560. Parameters:
  561.     None.
  562.  
  563. Usage:
  564.     reset_all_masks();
  565.  
  566. `co(10,1);/// refresh_desktop`co();   `keyword(source,[UW_WIN.C]~refresh_desktop);
  567.     This function walks through the linked list of windows and redraws
  568.     each.  This is a quick way to redisplay the screen.  It can be
  569.     useful when returning from executing another program, returning
  570.     from graphics mode, etc...
  571.  
  572. Prototype:
  573.     void refresh_desktop();
  574.  
  575. Parameters:
  576.     None
  577.  
  578. Usage:
  579.     refresh_desktop();
  580.  
  581. `co(10,1);/// refresh_column`co();   `keyword(source,[UW_WIN.C]~refresh_column);
  582.     This function walks through the linked list of windows checks to
  583.     see if each window contains a particular column.    If the window
  584.     contains the column, then only that column is refreshed.
  585.     This function is used internally by wn_move_left and wn_move_right.
  586.         
  587. Prototype:
  588.     void refresh_column( int col )
  589.  
  590. Parameters:
  591. `co(11,1);    int col`co();
  592.         The column to refresh (redraw).
  593.  
  594. Usage:
  595.     refresh_column( 20 );
  596.  
  597. `co(10,1);/// refresh_row`co();   `keyword(source,[UW_WIN.C]~refresh_row);
  598.     This function is the complement of refresh_column, and is used
  599.     internally by wn_move_up and wn_move_down.
  600.         
  601. Prototype:
  602.     void refresh_row( int row )
  603.  
  604. Parameters:
  605. `co(11,1);    int row`co();
  606.         The row to refresh (redraw).
  607.  
  608. Usage:
  609.     refresh_row( 5 );
  610.  
  611. `co(10,1);/// refresh_rect`co();   `keyword(source,[UW_WIN.C]~refresh_rect);
  612.     This function refreshes a rectangular portion of the manager's
  613.     screen, defined by a variable of type RECT.  The window manager
  614.     calls this function when a window is removed with remove_window.
  615.     The window's pane is used as the rectangular area passed.
  616.         
  617.     NOTE: Use the set_rect function to define a variable of type RECT.
  618.         
  619. Prototype:
  620.     void refresh_rect( RECT r );
  621.  
  622. Parameters:
  623. `co(11,1);    RECT r`co();
  624.         The rectangular area to refresh.
  625.  
  626. Usage:
  627.     RECT r;
  628.     ...
  629.     refresh_rect( r );
  630.  
  631. `co(4,7);─ End ──────────────────────────────────────────────────────────────────────`co();`sound(1024,10);
  632.